/**
 * @file mp3_import.c
 * @brief 导入歌曲文件相关
 */

/*********************
 *      INCLUDE
 *********************/
//导入库
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <libgen.h>
#include <tag_c.h>
#include <windows.h>
#include <commdlg.h>
#include <time.h>
#include <tchar.h>
#include <unistd.h>
//导入自定义头文件
#include "mp3_import.h"
#include "lv_demo_music.h"
#include "lrc_parser.h"
#include "message_popup.h"
#include "utf-8_to_gbk.h"

/*********************
 *      DEFINES
 *********************/
#ifdef _WIN32
#include <windows.h>
#include <direct.h>
#define PATH_SEPARATOR '\\'
#else
#include <sys/stat.h>
#define PATH_SEPARATOR '/'
#endif

/**********************
 *   GLOBAL FUNCTIONS
 **********************/

int mp3_import_main(int import_type){
    if (import_type != 0 && import_type != 1 ){
        printf("不存在该模式，模式只有0或1");
        return -1;
    }
    printf("----------用户选取要导入的mp3文件-----------\n");
    show_message_popup("请选择mp3文件，错误的文件类型无法导入", 5000);
    char* mp3_source_file = open_file_dialog();
    char* mp3_source_file_utf8 = gbk_to_utf8(mp3_source_file);      //生成utf-8字符，只用于打印到控制台

    if (mp3_source_file) {
        printf("用户选择mp3文件成功\n选择的mp3文件路径: %s\n", mp3_source_file_utf8);
    } else {
        printf("未选择mp3文件或选择取消\n");
        show_message_popup("未选择mp3文件或选择取消", 5000);
        return -2;
    }

    printf("-----------检测mp3文件拓展名是否正确----------\n");
    char expected_ext[50] = "mp3";
    int result = check_file_extension(mp3_source_file, expected_ext);
    if(result != 0){
        printf("mp3文件拓展名不匹配");
        show_message_popup("文件类型错误，应是mp3文件", 5000);
        return -3;
    }

    //-----------将文件复制到指定目录，并在文件名中加入时间戳----------
    printf("-----------将mp3文件复制到指定目录----------\n");
    char* new_mp3_source_file = copy_file_to_path_with_timestamp(mp3_source_file, utf8_to_gbk(soft_base_path_resource_mp3));
    char* new_mp3_source_file_utf8 = gbk_to_utf8(new_mp3_source_file);      //生成utf-8字符，只用于打印到控制台
    char* new_mp3_source_file_basename = extract_basename(new_mp3_source_file);      //生成文件基础名，用于函数

    if (new_mp3_source_file) {
        printf("成功复制，目标路径: %s\n", new_mp3_source_file_utf8);
    } else {
        printf("复制失败\n");
        show_message_popup("导入失败", 5000);
        return -4;
    }

    printf("-----------生成lrc文件----------\n");
    char* mp3_path = new_mp3_source_file;
    char* lrc_path = soft_base_path_resource_lrc;
    char* new_lrc_source_file = imprort_mp3_generate_lrc(mp3_path, utf8_to_gbk(lrc_path));
    char* new_lrc_source_file_utf8 = gbk_to_utf8(new_lrc_source_file);      //生成utf-8字符，只用于打印到控制台
    char* new_lrc_source_file_basename = extract_basename(new_lrc_source_file);      //生成文件基础名，用于函数

    if (new_lrc_source_file != NULL) {
        printf("生成的lrc文件路径: %s\n", new_lrc_source_file_utf8);
    } else {
        printf("生成lrc文件失败, 正在删除之前生成的mp3文件\n");
        result = 0;
        result = delete_file(new_mp3_source_file_basename, 0);
        if(result != 0){
            printf("删除mp3文件失败");
            return -5;
        }
        show_message_popup("导入失败", 5000);
        return -6;
    }

    if (import_type == 1){
        printf("----------用户选取要导入的歌词文件-----------\n");
        show_message_popup("请选择lrc文件或txt文件，错误的文件类型无法导入", 5000);
        char* lrc_source_file = open_file_dialog();
        char* lrc_source_file_utf8 = gbk_to_utf8(lrc_source_file);

        if (lrc_source_file) {
            printf("用户选择文件歌词成功\n选择的歌词文件路径: %s\n", lrc_source_file_utf8);
        } else {
            printf("未选择歌词文件或选择取消\n");
            printf("导入lrc文件失败, 正在删除之前生成的mp3文件和lrc文件\n");
            show_message_popup("未选择mp3文件或选择取消", 5000);
            int result1 = delete_file(new_mp3_source_file_basename, 0);
            int result2 = delete_file(new_lrc_source_file_basename, 1);
            if(result1 != 0){
                printf("删除mp3文件失败");
                return -5;
            }else{
                if(result2 != 0){
                    printf("删除lrc文件失败");
                    return -5;
                }
            }
            show_message_popup("导入失败", 5000);
            return -2;
        }

        printf("-----------检测歌词文件拓展名是否正确----------\n");
        char expected_ext1[50] = "lrc";
        int result1 = check_file_extension(lrc_source_file, expected_ext1);
        char expected_ext2[50] = "txt";
        int result2 = check_file_extension(lrc_source_file, expected_ext2);
        if(result1 != 0 && result2 != 0){
            printf("歌词文件拓展名不匹配");
            printf("导入lrc文件失败, 正在删除之前生成的mp3文件和lrc文件\n");
            int result1 = delete_file(new_mp3_source_file_basename, 0);
            int result2 = delete_file(new_lrc_source_file_basename, 1);
            if(result1 != 0){
                printf("删除mp3文件失败");
                return -5;
            }else{
                if(result2 != 0){
                    printf("删除lrc文件失败");
                    return -5;
                }
            }
            show_message_popup("文件类型错误，应该是lrc或者txt文件", 5000);
            return -3;
        }

        printf("-----------导入歌词----------\n");
        char* lrc_path1 = new_lrc_source_file;
        char* lrc_path2 = lrc_source_file;
        int result = merge_lrc_files_improved(lrc_path1, lrc_path2);

        free(lrc_source_file);
        free(lrc_source_file_utf8);
        if(result != 0){
            printf("导入lrc文件失败, 正在删除之前生成的mp3文件和lrc文件\n");
            int result1 = delete_file(new_mp3_source_file_basename, 0);
            int result2 = delete_file(new_lrc_source_file_basename, 1);
            if(result1 != 0){
                printf("删除mp3文件失败");
                return -5;
            }else{
                if(result2 != 0){
                    printf("删除lrc文件失败");
                    return -5;
                }
            }
            show_message_popup("导入失败", 5000);
            return -7;
        }
    }

    free(mp3_source_file);
    free(mp3_source_file_utf8);
    free(new_mp3_source_file);
    free(new_mp3_source_file_utf8);
    free(new_mp3_source_file_basename);
    free(new_lrc_source_file);
    free(new_lrc_source_file_utf8);
    free(new_lrc_source_file_basename);

    show_message_popup("导入歌曲成功，需要重新启动才能刷新歌曲", 5000);
    return 0;
}

/**
 * 删除指定路径的文件
 * @param file_name 要删除的文件名
 * @return 0表示成功，-1表示失败
 */
int delete_file(const char* file_name, int flag) {
    char complete_file_path[1024];
    if (flag == 0){
        snprintf(complete_file_path, 1024, "%s\\%s.mp3", utf8_to_gbk(soft_base_path_resource_mp3), file_name);
    }else if(flag == 1){
        snprintf(complete_file_path, 1024, "%s\\%s.lrc", utf8_to_gbk(soft_base_path_resource_lrc), file_name);
    }else{
        printf("错误：没有这种删除模式");
        return -1;
    }

    char* complete_file_path_utf8 = gbk_to_utf8(complete_file_path);      //生成utf-8字符，只用于打印到控制台;

    if (complete_file_path == NULL || strlen(complete_file_path) == 0) {
        printf("错误: 文件路径为空\n");
        return -1;
    }

    // 检查文件是否存在
    FILE* file = fopen(complete_file_path, "r");
    if (file == NULL) {
        printf("错误: 文件不存在或无法访问: %s\n", complete_file_path_utf8);
        return -1;
    }
    fclose(file);

    // 删除文件
    int result;

    result = DeleteFileA(complete_file_path);
    if (result == 0) {
        printf("错误: 删除文件失败 (错误代码: %lu)\n", GetLastError());
        return -1;
    }

    printf("成功删除文件: %s\n", complete_file_path_utf8);

    free(complete_file_path_utf8);

    return 0;
}


/**
 * 打开文件资源管理器，用户选择文件，函数返回文件路径。
 * @param sourceFileName 源文件名（可以包含路径）
 * @param targetPath     目标路径
 * @return 成功返回0，失败返回错误代码
 */
char* open_file_dialog() {
    OPENFILENAME ofn;
    char fileName[MAX_PATH] = "";

    // 初始化结构体
    ZeroMemory(&ofn, sizeof(ofn));
    ofn.lStructSize = sizeof(ofn);
    ofn.hwndOwner = NULL;
    ofn.lpstrFile = fileName;
    ofn.nMaxFile = MAX_PATH;
    ofn.lpstrFilter = "All Files\0*.*\0Text Files\0*.TXT\0";
    ofn.nFilterIndex = 1;
    ofn.lpstrFileTitle = NULL;
    ofn.nMaxFileTitle = 0;
    ofn.lpstrInitialDir = NULL;
    ofn.Flags = OFN_PATHMUSTEXIST | OFN_FILEMUSTEXIST;

    // 打开文件对话框
    if (GetOpenFileName(&ofn)) {
        // 复制文件路径到新分配的内存
        char* result = malloc(strlen(fileName) + 1);
        if (result) {
            strcpy(result, fileName);
            return result;
        }
    }

    return NULL;
}


/**
 * 检测文件扩展名是否匹配指定的扩展名
 * @param fileName 文件名（完整路径或纯文件名）
 * @param expectedExt 期望的扩展名（如 "txt", "jpg", 不含点号）
 * @return 成功返回0，失败返回错误代码
 */
int check_file_extension(const char* fileName, const char* expectedExt) {
    // 检查输入参数
    if (fileName == NULL || expectedExt == NULL) {
        printf("错误: 参数为空指针\n");
        return -1; // 参数错误
    }

    if (strlen(fileName) == 0 || strlen(expectedExt) == 0) {
        printf("错误: 空字符串\n");
        return -2; // 空字符串
    }

    // 查找最后一个点号（扩展名分隔符）
    const char* lastDot = strrchr(fileName, '.');
    if (lastDot == NULL) {
        printf("错误: 文件没有扩展名\n");
        return -3; // 没有扩展名
    }

    // 获取扩展名部分（去掉点号）
    const char* actualExt = lastDot + 1;

    // 检查扩展名是否为空
    if (strlen(actualExt) == 0) {
        printf("错误: 扩展名为空\n");
        return -4; // 扩展名为空
    }

    // 比较扩展名（不区分大小写）
    if (_stricmp(actualExt, expectedExt) == 0) {
        printf("文件扩展名匹配\n");
        return 0; // 扩展名匹配

    } else {
        const char* actualExt = get_file_extension(fileName);
        if (actualExt) {
            printf("错误: 扩展名不匹配 (实际: %s, 期望: %s)\n", actualExt, expectedExt);
        } else {
            printf("错误: 扩展名不匹配\n");
        }
        return -5; // 扩展名不匹配
    }
    printf("错误: 未知错误代码\n");

}

/**
 * 获取文件的扩展名（返回静态缓冲区，非线程安全）
 * @param fileName 文件名
 * @return 扩展名字符串（不含点号），失败返回NULL
 */
const char* get_file_extension(const char* fileName) {
    static char ext[32];

    if (fileName == NULL) {
        return NULL;
    }

    const char* lastDot = strrchr(fileName, '.');
    if (lastDot == NULL || strlen(lastDot) <= 1) {
        return NULL;
    }

    // 复制扩展名到静态缓冲区
    strncpy(ext, lastDot + 1, sizeof(ext) - 1);
    ext[sizeof(ext) - 1] = '\0';

    return ext;
}

/**
 * 给文件名添加时间戳，并复制到指定目录。
 * @param sourceFileName 源文件名（可以包含路径）
 * @param targetPath     目标路径
 * @return 成功返回0，失败返回错误代码
 */
char* copy_file_to_path_with_timestamp(const char* sourceFileName, const char* targetPath) {

    // 检查输入参数
    if (sourceFileName == NULL || targetPath == NULL) {
        printf("错误: 参数为空\n");
        return NULL;
    }

    // 检查源文件是否存在
    if (GetFileAttributesA(sourceFileName) == INVALID_FILE_ATTRIBUTES) {
        printf("错误: 源文件不存在\n");
        return NULL;
    }

    // 检查目标路径是否存在，如果不存在则创建
    if (GetFileAttributesA(targetPath) == INVALID_FILE_ATTRIBUTES) {
        if (!CreateDirectoryA(targetPath, NULL)) {
            printf("错误: 目标路径不存在且创建失败\n");
            return NULL;
        }
    }

    // 从源文件名中提取路径和文件名部分
    const char* fileNameOnly = strrchr(sourceFileName, '\\');
    if (fileNameOnly == NULL) {
        fileNameOnly = strrchr(sourceFileName, '/');
        if (fileNameOnly == NULL) {
            fileNameOnly = sourceFileName;
        } else {
            fileNameOnly++; // 跳过斜杠
        }
    } else {
        fileNameOnly++; // 跳过反斜杠
    }

    // 提取文件扩展名
    const char* fileExt = strrchr(fileNameOnly, '.');
    char fileNameWithoutExt[256] = "";
    char extension[32] = "";

    if (fileExt != NULL) {
        // 分离文件名和扩展名
        size_t nameLength = fileExt - fileNameOnly;
        strncpy(fileNameWithoutExt, fileNameOnly, nameLength);
        fileNameWithoutExt[nameLength] = '\0';
        strcpy(extension, fileExt);
    } else {
        // 没有扩展名
        strcpy(fileNameWithoutExt, fileNameOnly);
    }

    // 获取当前时间戳
    time_t now = time(NULL);
    struct tm* localTime = localtime(&now);

    // 格式化时间戳为 YYYYMMDDHHMMSS 格式
    char timestamp[15];
    strftime(timestamp, sizeof(timestamp), "%Y%m%d%H%M%S", localTime);

    // 构建带时间戳的新文件名
    char newFileName[300];
    if (fileExt != NULL) {
        // 有扩展名：文件名+时间戳+扩展名
        sprintf(newFileName, "%s-%s%s", timestamp, fileNameWithoutExt, extension);
        //sprintf(newFileName, "%s%s", timestamp, extension);
    } else {
        // 无扩展名：文件名+时间戳
        sprintf(newFileName, "%s-%s", timestamp, fileNameWithoutExt);
        //sprintf(newFileName, "%s", timestamp);
    }

    // 构建目标文件完整路径
    char targetFile[MAX_PATH];
    strcpy(targetFile, targetPath);

    // 确保目标路径以反斜杠结尾
    size_t targetLen = strlen(targetFile);
    if (targetLen > 0 && targetFile[targetLen-1] != '\\') {
        strcat(targetFile, "\\");
    }

    strcat(targetFile, newFileName);

    printf("原文件名: %s\n", gbk_to_utf8(fileNameOnly));
    printf("新文件名: %s\n", gbk_to_utf8(newFileName));

    // 使用CopyFileA函数复制文件到指定目录（若存在则覆盖）
    if (CopyFileA(sourceFileName, targetFile, FALSE)) {
        // 返回动态分配的副本
        char* result = malloc(MAX_PATH);
        if (result) strcpy(result, targetFile);
        return result;
    } else {
        DWORD error = GetLastError();
        printf("复制文件失败，错误代码: %lu\n", error);
        return NULL;
    }
    printf("未知错误\n");
}

// 确保路径以分隔符结尾
void ensure_trailing_separator(char* path, size_t size) {
    size_t len = strlen(path);
    if (len > 0 && len < size - 1) {
        // 检查最后一个字符是否是路径分隔符
        if (path[len-1] != PATH_SEPARATOR) {
            // 添加路径分隔符
            if (len < size - 2) {
                path[len] = PATH_SEPARATOR;
                path[len+1] = '\0';
            }
        }
    }
}

/**
 * 从文件路径中提取基础名（不包含路径和扩展名）
 * @param path 完整的文件路径
 * @return 提取到的基础名（需要调用者释放内存）
 */
char* extract_basename(const char* path) {
    if (path == NULL || strlen(path) == 0) {
        return NULL;
    }

    // 复制路径以便处理
    char* temp_path = strdup(path);
    if (temp_path == NULL) {
        return NULL;
    }

    // 查找最后一个路径分隔符
    char* last_slash = NULL;
    char* slash1 = strrchr(temp_path, '\\');
    char* slash2 = strrchr(temp_path, '/');

    if (slash1 != NULL && slash2 != NULL) {
        last_slash = (slash1 > slash2) ? slash1 : slash2;
    } else if (slash1 != NULL) {
        last_slash = slash1;
    } else if (slash2 != NULL) {
        last_slash = slash2;
    }

    // 获取文件名（包含扩展名）
    char* filename = (last_slash != NULL) ? last_slash + 1 : temp_path;

    // 查找最后一个点号（扩展名分隔符）
    char* last_dot = strrchr(filename, '.');

    // 计算基础名长度
    size_t basename_length;
    if (last_dot != NULL && last_dot > filename) {
        // 有点号且不在开头
        basename_length = last_dot - filename;
    } else {
        // 没有扩展名
        basename_length = strlen(filename);
    }

    // 分配内存并复制基础名
    char* basename = (char*)malloc(basename_length + 1);
    if (basename == NULL) {
        free(temp_path);
        return NULL;
    }

    strncpy(basename, filename, basename_length);
    basename[basename_length] = '\0';

    free(temp_path);
    return basename;
}

//输入mp3路径生成lrc文件
const char* imprort_mp3_generate_lrc(const char* mp3_path, const char* lrc_dir) {
    char * mp3_path_utf8 = gbk_to_utf8(mp3_path);

    // 检查输入参数
    if (mp3_path == NULL || lrc_dir == NULL) {
        printf("错误: MP3文件路径或LRC目录路径不能为空\n");
        return NULL;
    }

    // 检查MP3文件是否存在
    FILE *test_file = fopen(mp3_path, "rb");
    if (test_file == NULL) {
        printf("错误: MP3文件不存在: %s\n", mp3_path_utf8);
        return NULL;
    }
    fclose(test_file);


    // 从MP3路径中提取文件名（不含扩展名）
    char *mp3_path_copy = strdup(mp3_path);
    if (mp3_path_copy == NULL) {
        printf("错误: 内存分配失败\n");
        return NULL;
    }

    char *base_name = extract_basename(mp3_path_copy);
    char file_name[256];
    strncpy(file_name, base_name, sizeof(file_name) - 1);
    // 移除扩展名
    char *dot = strrchr(file_name, '.');
    if (dot != NULL) {
        *dot = '\0';
    }

    // 构建完整的LRC文件路径
    char lrc_path[1024];
    strncpy(lrc_path, lrc_dir, sizeof(lrc_path) - 1);
    lrc_path[sizeof(lrc_path) - 1] = '\0';

    ensure_trailing_separator(lrc_path, sizeof(lrc_path));
    strncat(lrc_path, file_name, strlen(file_name)*2 );
    strncat(lrc_path, ".lrc", 4);

    char* lrc_path_utf8 = gbk_to_utf8(lrc_path);

    // 打开MP3文件读取元数据
    TagLib_File *file = taglib_file_new(mp3_path);
    if (file == NULL) {
        printf("错误: 无法打开MP3文件或文件格式不支持: %s\n", mp3_path_utf8);
        free(mp3_path_copy);
        return NULL;
    }

    // 获取标签信息
    TagLib_Tag *tag = taglib_file_tag(file);

    // 获取音频属性
    TagLib_AudioProperties *properties = taglib_file_audioproperties(file);

    // 提取MP3文件信息，处理空值和空字符串
    const char *title = (tag && taglib_tag_title(tag) && strlen(taglib_tag_title(tag)) > 0)
                    ? taglib_tag_title(tag) : "无歌曲名";
    const char *artist = (tag && taglib_tag_artist(tag) && strlen(taglib_tag_artist(tag)) > 0)
                    ? taglib_tag_artist(tag) : "未知艺术家";
    const char *album = (tag && taglib_tag_album(tag) && strlen(taglib_tag_album(tag)) > 0)
                    ? taglib_tag_album(tag) : "无专辑信息";
    const char *genre = (tag && taglib_tag_genre(tag) && strlen(taglib_tag_genre(tag)) > 0)
                    ? taglib_tag_genre(tag) : "无流派信息";

    // 获取时长（秒），如果没有则设为180
    int length = 180;
    if (properties != NULL) {
        length = taglib_audioproperties_length(properties);
        if (length <= 0) length = 180;
    }

    // 打开LRC文件进行写入（使用二进制模式以确保UTF-8编码）
    FILE *lrc_file = fopen(lrc_path, "wb");
    if (lrc_file == NULL) {
        printf("错误: 无法创建LRC文件: %s\n", lrc_path_utf8);
        free(mp3_path_copy);
        taglib_file_free(file);
        return NULL;
    }


    // 写入LRC文件头信息
    fprintf(lrc_file, "[ti:%s]\n", title);
    fprintf(lrc_file, "[ar:%s]\n", artist);
    fprintf(lrc_file, "[al:%s]\n", album);
    fprintf(lrc_file, "[ge:%s]\n", genre);
    fprintf(lrc_file, "[length:%d]\n", length);
    fprintf(lrc_file, "[by:无编辑信息]\n");
    fprintf(lrc_file, "[offset:0]\n");
    fprintf(lrc_file, "[file:%s]\n", gbk_to_utf8(file_name));
    fprintf(lrc_file, "[condition:正常]\n");
    fprintf(lrc_file, "\n");

    // 添加示例歌词时间戳
    fprintf(lrc_file, "[00:00.00]无歌词数据\n");

    printf("成功生成LRC文件: %s\n", lrc_path_utf8);
    printf("歌曲信息:\n");
    printf("  标题: %s\n", title);
    printf("  艺术家: %s\n", artist);
    printf("  专辑: %s\n", album);
    printf("  流派: %s\n", genre);
    printf("  时长: %d秒\n", length);
    printf("  编码: UTF-8\n");

   // 关闭文件和释放资源
    fclose(lrc_file);
    free(mp3_path_copy);
    taglib_file_free(file);
    free(mp3_path_utf8);
    free(lrc_path_utf8);

    // 返回生成的LRC文件完整路径
    return strdup(lrc_path);


}

// 检查是否为有效的UTF-8序列
int is_valid_utf8(const unsigned char* data, size_t len) {
    size_t i = 0;
    while (i < len) {
        unsigned char c = data[i];

        if (c <= 0x7F) {
            // ASCII字符
            i++;
        } else if ((c & 0xE0) == 0xC0) {
            // 2字节UTF-8
            if (i + 1 >= len || (data[i+1] & 0xC0) != 0x80) return 0;
            i += 2;
        } else if ((c & 0xF0) == 0xE0) {
            // 3字节UTF-8
            if (i + 2 >= len || (data[i+1] & 0xC0) != 0x80 || (data[i+2] & 0xC0) != 0x80) return 0;
            i += 3;
        } else if ((c & 0xF8) == 0xF0) {
            // 4字节UTF-8
            if (i + 3 >= len || (data[i+1] & 0xC0) != 0x80 ||
                (data[i+2] & 0xC0) != 0x80 || (data[i+3] & 0xC0) != 0x80) return 0;
            i += 4;
        } else {
            return 0;
        }
    }
    return 1;
}

// 编码检测
EncodingType detect_file_encoding_advanced(const char* filename) {
    FILE* file = fopen(filename, "rb");
    if (!file) return ENCODING_UNKNOWN;

    // 读取文件前部内容进行检测
    unsigned char buffer[4096];
    size_t bytes_read = fread(buffer, 1, sizeof(buffer), file);
    fclose(file);

    if (bytes_read < 2) return ENCODING_UNKNOWN;

    // 检查BOM
    if (bytes_read >= 3 && buffer[0] == 0xEF && buffer[1] == 0xBB && buffer[2] == 0xBF) {
        return ENCODING_UTF8_BOM;
    }
    if (bytes_read >= 2 && buffer[0] == 0xFF && buffer[1] == 0xFE) {
        return ENCODING_UTF16_LE;
    }
    if (bytes_read >= 2 && buffer[0] == 0xFE && buffer[1] == 0xFF) {
        return ENCODING_UTF16_BE;
    }

    // 检查是否为有效的UTF-8
    if (is_valid_utf8(buffer, bytes_read)) {
        return ENCODING_UTF8;
    }

    // 默认为GBK（中文Windows系统常见编码）
    return ENCODING_GBK;
}

// 改进的文件读取函数，保持原始编码
char* read_file_with_auto_encoding(const char* filename, EncodingType* detected_encoding) {
    FILE* file = fopen(filename, "rb");
    if (!file) return NULL;

    fseek(file, 0, SEEK_END);
    long file_size = ftell(file);
    fseek(file, 0, SEEK_SET);

    // 检测编码
    *detected_encoding = detect_file_encoding_advanced(filename);

    // 根据编码决定是否跳过BOM
    size_t skip_bytes = 0;
    if (*detected_encoding == ENCODING_UTF8_BOM) skip_bytes = 3;
    else if (*detected_encoding == ENCODING_UTF16_LE || *detected_encoding == ENCODING_UTF16_BE) skip_bytes = 2;

    char* buffer = (char*)malloc(file_size - skip_bytes + 1);
    if (!buffer) {
        fclose(file);
        return NULL;
    }

    fseek(file, skip_bytes, SEEK_SET);
    size_t bytes_read = fread(buffer, 1, file_size - skip_bytes, file);
    buffer[bytes_read] = '\0';
    fclose(file);

    return buffer;
}

// 编码转换函数
char* convert_encoding(const char* src, EncodingType src_encoding, EncodingType dst_encoding) {
    if (src_encoding == dst_encoding) {
        return strdup(src);
    }

    // 如果源编码是UTF-8系列，目标也是UTF-8，不需要转换
    if ((src_encoding == ENCODING_UTF8 || src_encoding == ENCODING_UTF8_BOM) &&
        dst_encoding == ENCODING_UTF8) {
        return strdup(src);
    }

    // GBK/其他编码转UTF-8
    if ((src_encoding == ENCODING_GBK || src_encoding == ENCODING_OTHER) &&
        dst_encoding == ENCODING_UTF8) {
        int wide_len = MultiByteToWideChar(CP_ACP, 0, src, -1, NULL, 0);
        if (wide_len == 0) return strdup(src); // 转换失败，返回原字符串

        wchar_t* wide_str = (wchar_t*)malloc(wide_len * sizeof(wchar_t));
        if (!wide_str) return strdup(src);

        MultiByteToWideChar(CP_ACP, 0, src, -1, wide_str, wide_len);

        int utf8_len = WideCharToMultiByte(CP_UTF8, 0, wide_str, -1, NULL, 0, NULL, NULL);
        char* utf8_str = (char*)malloc(utf8_len);
        if (utf8_str) {
            WideCharToMultiByte(CP_UTF8, 0, wide_str, -1, utf8_str, utf8_len, NULL, NULL);
        }

        free(wide_str);
        return utf8_str ? utf8_str : strdup(src);
    }

    // UTF-8转GBK（如果需要）
    if ((src_encoding == ENCODING_UTF8 || src_encoding == ENCODING_UTF8_BOM) &&
        dst_encoding == ENCODING_GBK) {
        int wide_len = MultiByteToWideChar(CP_UTF8, 0, src, -1, NULL, 0);
        if (wide_len == 0) return strdup(src);

        wchar_t* wide_str = (wchar_t*)malloc(wide_len * sizeof(wchar_t));
        if (!wide_str) return strdup(src);

        MultiByteToWideChar(CP_UTF8, 0, src, -1, wide_str, wide_len);

        int gbk_len = WideCharToMultiByte(CP_ACP, 0, wide_str, -1, NULL, 0, NULL, NULL);
        char* gbk_str = (char*)malloc(gbk_len);
        if (gbk_str) {
            WideCharToMultiByte(CP_ACP, 0, wide_str, -1, gbk_str, gbk_len, NULL, NULL);
        }

        free(wide_str);
        return gbk_str ? gbk_str : strdup(src);
    }

    return strdup(src);
}

// 跳过LRC头部信息，找到歌词开始位置
const char* skip_lrc_header(const char* content) {
    const char* ptr = content;
    int line_count = 0;

    while (*ptr) {
        // 查找行首的 '['
        if (*ptr == '[') {
            const char* line_start = ptr;
            ptr++;

            // 检查这是否是时间标签 [mm:ss.xx]
            if (isdigit(ptr[0]) && isdigit(ptr[1]) && ptr[2] == ':' &&
                isdigit(ptr[3]) && isdigit(ptr[4])) {
                // 找到第一个时间标签，返回这个位置
                return line_start;
            }

            // 检查其他可能的头部标签
            const char* tag_end = strchr(line_start, ']');
            if (tag_end) {
                // 常见的LRC头部标签
                if (strncmp(line_start, "[ti:", 4) == 0 ||
                    strncmp(line_start, "[ar:", 4) == 0 ||
                    strncmp(line_start, "[al:", 4) == 0 ||
                    strncmp(line_start, "[by:", 4) == 0 ||
                    strncmp(line_start, "[offset:", 8) == 0 ||
                    strncmp(line_start, "[length:", 8) == 0 ||
                    strncmp(line_start, "[ge:", 4) == 0 ||
                    strncmp(line_start, "[file:", 6) == 0 ||
                    strncmp(line_start, "[condition:", 11) == 0) {
                    // 这是头部标签，跳过这一行
                    ptr = tag_end + 1;
                    if (*ptr == '\n') ptr++;
                    else if (*ptr == '\r' && ptr[1] == '\n') ptr += 2;
                    continue;
                }
            }
        }

        // 移动到下一行
        const char* next_line = strchr(ptr, '\n');
        if (next_line) {
            ptr = next_line + 1;
            line_count++;

            // 如果已经检查了很多行还没找到时间标签，可能格式有问题
            if (line_count > 50) {
                break;
            }
        } else {
            break;
        }
    }

    // 如果没有找到时间标签，返回原始内容
    return content;
}

// 安全读取LRC文件1的所有内容直到第一个时间标签
char* read_lrc1_until_first_lyric(const char* lrc_path1) {
    FILE* file = fopen(lrc_path1, "r");
    if (!file) {
        printf("错误: 无法打开文件: %s\n", lrc_path1);
        return NULL;
    }

    // 动态分配内存存储头部
    char* header = (char*)malloc(8192); // 更大的缓冲区
    if (!header) {
        fclose(file);
        return NULL;
    }
    header[0] = '\0';

    char line[256];
    int found_first_lyric = 0;
    int header_size = 0;

    while (fgets(line, sizeof(line), file) && !found_first_lyric) {
        // 检查是否是时间标签（歌词开始）
        if (line[0] == '[') {
            // 检查是否是时间标签 [mm:ss.xx]
            if (isdigit(line[1]) && isdigit(line[2]) && line[3] == ':' &&
                isdigit(line[4]) && isdigit(line[5])) {
                found_first_lyric = 1;
            } else {
                // 不是时间标签，添加到头部
                if (header_size + strlen(line) < 8191) {
                    strcat(header, line);
                    header_size += strlen(line);
                }
            }
        } else {
            // 不是以[开头的行，也添加到头部
            if (header_size + strlen(line) < 8191) {
                strcat(header, line);
                header_size += strlen(line);
            }
        }
    }

    fclose(file);
    return header;
}

// 合并歌词文件主函数
int merge_lrc_files_improved(const char* lrc_path1, const char* lrc_path2) {
    char* lrc_path1_utf8 = gbk_to_utf8(lrc_path1);
    char* lrc_path2_utf8 = gbk_to_utf8(lrc_path2);

    printf("开始处理文件:\n");
    printf("目标文件: %s\n", lrc_path1_utf8);
    printf("源文件: %s\n", lrc_path2_utf8);

    // 检测源文件编码
    EncodingType src_encoding;
    char* content = read_file_with_auto_encoding(lrc_path2, &src_encoding);

    if (!content) {
        printf("错误: 无法读取文件: %s\n", lrc_path2_utf8);
        return -1;
    }

    const char* encoding_str = "未知";
    switch (src_encoding) {
        case ENCODING_UTF8: encoding_str = "UTF-8"; break;
        case ENCODING_UTF8_BOM: encoding_str = "UTF-8 BOM"; break;
        case ENCODING_GBK: encoding_str = "GBK"; break;
        case ENCODING_UTF16_LE: encoding_str = "UTF-16 LE"; break;
        case ENCODING_UTF16_BE: encoding_str = "UTF-16 BE"; break;
        default: encoding_str = "其他"; break;
    }
    printf("检测到源文件编码: %s\n", encoding_str);

    // 如果是UTF-16，需要特殊处理（这里简化处理）
    if (src_encoding == ENCODING_UTF16_LE || src_encoding == ENCODING_UTF16_BE) {
        printf("警告: UTF-16编码需要额外处理，当前实现可能无法正确处理\n");
        free(content);
        return -2;
    }

    // 转换为UTF-8（如果需要）
    char* utf8_content = convert_encoding(content, src_encoding, ENCODING_UTF8);
    free(content);

    if (!utf8_content) {
        printf("错误: 编码转换失败\n");
        return -3;
    }

    // 检查是否是JSON格式并提取歌词
    char* lyric_content = NULL;
    if (strstr(utf8_content, "\"lyric\":\"") != NULL) {
        printf("检测到JSON格式，提取歌词内容...\n");

        const char* lyric_key = "\"lyric\":\"";
        const char* lyric_start = strstr(utf8_content, lyric_key);
        if (lyric_start) {
            lyric_start += strlen(lyric_key);
            const char* lyric_end = strstr(lyric_start, "\"");
            if (lyric_end) {
                size_t lyric_len = lyric_end - lyric_start;
                lyric_content = (char*)malloc(lyric_len + 1);
                if (lyric_content) {
                    strncpy(lyric_content, lyric_start, lyric_len);
                    lyric_content[lyric_len] = '\0';

                    // 处理转义字符
                    char* src = lyric_content;
                    char* dst = lyric_content;
                    while (*src) {
                        if (*src == '\\' && src[1] == 'n') {
                            *dst++ = '\n';
                            src += 2;
                        } else if (*src == '\\' && src[1] == 't') {
                            *dst++ = '\t';
                            src += 2;
                        } else if (*src == '\\' && src[1] == '\\') {
                            *dst++ = '\\';
                            src += 2;
                        } else if (*src == '\\' && src[1] == '\"') {
                            *dst++ = '\"';
                            src += 2;
                        } else if (*src == '\\' && src[1] == 'r') {
                            *dst++ = '\r';
                            src += 2;
                        } else {
                            *dst++ = *src++;
                        }
                    }
                    *dst = '\0';

                    free(utf8_content);
                    utf8_content = lyric_content;
                    printf("成功从JSON提取歌词\n");
                }
            }
        }
        if (!lyric_content) {
            printf("警告: 未能从JSON中提取歌词，使用原始内容\n");
        }
    }

    // 跳过LRC文件2中的头部信息，只保留歌词部分
    printf("跳过LRC文件2的头部信息...\n");
    const char* lyric_only_content = skip_lrc_header(utf8_content);

    // 如果跳过了头部，需要重新分配内存
    if (lyric_only_content != utf8_content) {
        char* new_content = strdup(lyric_only_content);
        free(utf8_content);
        utf8_content = new_content;
        printf("已跳过LRC文件2的头部信息\n");
    } else {
        printf("未找到明显的头部信息，使用完整内容\n");
    }

    // 检查时间标签（简化版本）
    int has_time_tags = 0;
    const char* ptr = utf8_content;
    while (*ptr && !has_time_tags) {
        if (*ptr == '[' && isdigit(ptr[1]) && isdigit(ptr[2]) && ptr[3] == ':') {
            has_time_tags = 1;
            break;
        }
        ptr++;
    }

    if (!has_time_tags) {
        printf("错误: 文件中没有找到时间标签\n");
        free(utf8_content);
        return -4;
    }

    // 读取目标LRC文件的头部（直到第一个歌词时间标签）
    char* header = read_lrc1_until_first_lyric(lrc_path1);
    if (!header) {
        printf("错误: 无法读取目标文件的头部信息: %s\n", lrc_path1);
        free(utf8_content);
        return;
    }

    // 确保头部以换行符结束
    size_t header_len = strlen(header);
    if (header_len > 0 && header[header_len-1] != '\n') {
        if (header_len < 8190) {
            strcat(header, "\n");
        }
    }

    printf("读取到的头部信息:\n%s\n", header);

    // 重新写入文件（UTF-8无BOM）
    FILE* target_file = fopen(lrc_path1, "wb");
    if (!target_file) {
        printf("错误: 无法写入目标文件: %s\n", lrc_path1_utf8);
        free(utf8_content);
        return -6;
    }

    // 写入头部
    fwrite(header, 1, strlen(header), target_file);
    fwrite("\n", 1, 1, target_file); // 确保头部后有换行

    // 写入歌词内容
    fwrite(utf8_content, 1, strlen(utf8_content), target_file);

    fclose(target_file);
    free(utf8_content);

    printf("成功合并歌词文件\n");

    free(lrc_path1_utf8);
    free(lrc_path2_utf8);
    return 0;
}



